home *** CD-ROM | disk | FTP | other *** search
-
-
-
- Chapter 5
- ENCAPSULATION
-
- As mentioned in Chapter 1, object oriented programming will seem
- very unnatural to a programmer with a lot of procedural programming
- experience. This chapter is the beginning of the definition of
- object oriented programming, and we will study the topic of
- encapsulation which is a "divide and conquer" technique. As we
- stated earlier, there are a lot of new terms used with object
- oriented programming. Don't be intimidated by the new terminology,
- we will study the terms one at a time in a meaningful order.
-
- Encapsulation is the process of forming objects which we will
- discuss throughout this chapter. An encapsulated object is often
- called an abstract data type and it is what object oriented
- programming is all about. Without encapsulation, which involves
- the use of one or more classes, there is no object oriented
- programming. Of course there are other topics concerning object
- oriented programming, but this is the cornerstone.
-
-
- NO INFORMATION HIDING
- _________________________________________________________________
-
- The program named OPEN.CPP is a really stupid ==============
- program because it does next to nothing but it OPEN.CPP
- will be the beginning point for our discussion ==============
- of encapsulation, otherwise known as information
- hiding. Information hiding is an important part
- of object oriented programming and you should have a good grasp of
- what it is and what it will do for you by the time we finish this
- chapter.
-
- A very simple structure is defined in lines 4 through 6 which
- contains only a single int type variable within the structure.
- This is sort of a silly thing to do but it will illustrate the
- problem we wish to overcome in this chapter. Three variables are
- declared in line 10, each of which contains a single int type
- variable and each of the three variables are available anywhere
- within the main function. Each variable can be assigned,
- incremented, read, modified, or have any number of operations
- performed on it. A few of the operations are illustrated in lines
- 13 through 21 and should be self explanatory to anyone with a
- little experience with the C programming language.
-
- An isolated local variable named piggy is declared and used in the
- same section of code to illustrate that there is nothing magic
- about this code.
-
- Study this simple program carefully because it is the basis for
- beginning our study of encapsulation. Be sure to compile and
- execute this program, then we will go on to the next example
- program.
-
- Page 5-1
-
- Chapter 5 - Encapsulation
-
- INFORMATION HIDING
- _________________________________________________________________
-
- Examine the program named CLAS.CPP for our first ==============
- example of a program with a little information CLAS.CPP
- hiding contained in it. This program is ==============
- identical to the last one except for the way it
- does a few of its operations. We will take the
- differences one at a time and explain what is happening here. Keep
- in mind that this is a trivial program and the safeguards built
- into it are not needed for such a simple program but are used here
- to illustrate how to use these techniques in a larger much more
- complicated program.
-
- The first difference is that we have a class instead of a structure
- beginning in line 4 of this program. The only difference between
- a class and a structure is that a class begins with a private
- section whereas a structure has no private section automatically
- defined. Everything in a structure is defaulted to public by
- definition of the C++ language, but you can declare a private
- section in a structure if you so desire. The keyword class is used
- to declare a class as illustrated here.
-
-
- WHAT IS A PRIVATE SECTION?
- _________________________________________________________________
-
- A private section of a class is a section of data which cannot be
- accessed outside of the class, it is hidden from any outside
- access. Thus, the variable named data_store which is a part of the
- object (an object will be defined completely later) named dog1
- declared in line 23 is not available for use anywhere in the main
- program. It seems a little dumb to declare a variable in the main
- program that we cannot use, but that is exactly what we did.
-
- The class is composed of the single variable named data_store and
- two functions, one named set() and the other named get_value().
- A more complete definition of a class is a group of variables and
- one or more functions that can operate on that data. Stay with us,
- we will tie this all together in a meaningful and useful way very
- soon.
-
-
- WHAT IS A PUBLIC SECTION?
- _________________________________________________________________
-
- A new keyword, public, is introduced in line 6 which states that
- anything following this keyword can be accessed from the main
- program or any function that is within the scope of an object of
- the given class. Because the two functions are defined following
- the keyword public, they are both public and available for use in
- the calling function or any other function that is within the scope
- of the calling function. You should keep in mind that the private
- variable is not available to the calling program. Thus, we can
-
- Page 5-2
-
- Chapter 5 - Encapsulation
-
- only use the variable by calling one of the two functions defined
- as a part of the class. These are called member functions because
- they are members of the class.
-
- Since we have declared two functions, we need to define them, by
- saying what each function will actually do. This is done in lines
- 11 through 19 where they are each defined in the normal way except
- that the class name is prepended onto the function name and
- separated from it by a double colon. These two function
- definitions are called the implementation of the functions. The
- class name is required because we can use the same function name
- in other classes and the compiler must know with which class to
- associate each function implementation.
-
- One of the key points to be made here is that the private data
- contained within the class is available within the implementation
- of the member functions of the class for modification or reading
- in the normal manner. You can do anything with the private data
- within the function implementations which are a part of that class,
- but the private data of other classes is hidden and not available
- within the member functions of this class. This is the reason we
- must prepend the class name to the function names of this class
- when defining them.
-
-
- In C++ we have three scopes of variables, local, file and class.
- Local variables are localized to a single function and file
- variables are available anywhere in a file following their
- definition. A variable with class scope is available anywhere
- within the scope of a class and nowhere else.
-
- It would be well to mention at this point that it is legal to
- include variables and functions in the private part and additional
- variables and functions in the public part. In most practical
- situations, variables are included in only the private part and
- functions are included in only the public part of a class
- definition. Occasionally, variables or functions are used in the
- other part. This sometimes leads to a very practical solution to
- a particular problem, but in general, the entities are used only
- in the places mentioned.
-
-
- MORE NEW TERMINOLOGY
- _________________________________________________________________
-
- If we are going to learn how to effectively use object oriented
- programming, we must learn the new terminology of the technique,
- so we will list a few of them here and begin using them in the text
- to get you used to seeing and using them.
-
- A class is a grouping of data and methods. A class is
- very much like a type as used in ANSI-C, it is only a
- pattern to be used to create a variable which can be
- manipulated in a program.
-
- Page 5-3
-
- Chapter 5 - Encapsulation
-
-
- An object is an instance of a class. An object is what
- you actually use in a program since it has values and can
- be changed.
-
- A method is a function contained within the class. You
- will find the functions used within a class referred to
- as a method.
-
- A message is the same thing as a function call. In
- object oriented programming, we send messages instead of
- calling functions. For the time being, you can think of
- them as identical. Later in this tutorial we will see
- that they are in fact slightly different.
-
- With all the new terminology, we will continue our study of the
- program named CLAS.CPP and show you how to use the class. We can
- now say that we have a class composed of one variable and two
- methods. The methods operate on the variable contained in the
- class when they receive messages to do so. In this tutorial we
- will use the terms object and variable interchangeably because both
- names are very descriptive of what the object really is.
-
- This is a small point but it could be easily overlooked. Lines 7
- and 8 of this program are actually the prototypes for the two
- methods, and is our first example of the use of a prototype within
- a class. This is the reason we spent so much time on prototypes
- in the last chapter. You will notice line 7 which says that the
- method named set requires one parameter of type int and returns
- nothing, hence the return type is void. The method named
- get_value() however, according to line 8, has no input parameters
- but returns an int type value to the caller.
-
-
- SENDING A MESSAGE
- _________________________________________________________________
-
- Following all of the definitions in lines 1 through 19, we finally
- come to the program where we actually use the class. In line 23
- we declare three objects of the class one_datum and name the
- objects dog1, dog2, and dog3. Each object contains a single data
- point which we can set through use of one method or read its value
- through use of the other method. In line 26, we send a message to
- the object named dog1 instructing it to set its internal value to
- 12, and even though this looks like a function call, it is properly
- called sending a message to a method. Remember that the object
- named dog1 has a method associated with it called set() that sets
- its internal value to the actual parameter included within the
- message. You will notice that the form is very much like the means
- of accessing the elements of a structure. You mention the name of
- the object with a dot connecting it to the name of the method. In
- a similar manner, we send a message to each of the other two
- objects dog2 and dog3 to set their values to those indicated.
-
- Page 5-4
-
- Chapter 5 - Encapsulation
-
- Lines 31 and 32 have been commented out because the operations are
- illegal since the variable named data_store is private and not
- available to the code outside of the object itself. It should be
- obvious, but it will be pointed out that the data contained within
- the object named dog1 is not available within the methods of dog2
- or dog3 because they are different objects. These rules are all
- devised to help you develop better code more quickly and you will
- soon see how they help.
-
- The other method defined for each object is used in lines 34
- through 36 to illustrate how it can be used. In each case, another
- message is sent to each object and the returned result is output
- to the monitor via the stream library.
-
-
-
- USING A NORMAL VARIABLE
- _________________________________________________________________
-
- There is another variable named piggy declared and used throughout
- this example program that illustrates that a normal variable can
- be intermixed with the objects and used in the normal manner. The
- use of this variable should pose no problem to you, so after you
- understand the program, be sure to compile and execute it. It
- would be a good exercise for you to remove the comments from lines
- 31 and 32 to see what kind of error message your compiler issues.
-
- This program illustrates information hiding but it will not be
- clear to you that it really does anything worthwhile until we study
- the next two programs. Be sure to compile and execute this program
- before continuing on to the next example program.
-
-
-
- A PROGRAM WITH PROBLEMS
- _________________________________________________________________
-
- Examine the program named OPENPOLE.CPP for an ================
- example of a program with a few serious problems OPENPOLE.CPP
- that will be overcome in the next example ================
- program by using the principles of
- encapsulation.
-
- We have two structures declared, one being a rectangle and the
- other being a pole. The data fields should be self explanatory
- with the exception of the depth of the flagpole which is the depth
- it is buried in the ground, the overall length of the pole is
- therefore the sum of the length and the depth.
-
- Based on your experience with ANSI-C, you should have no problem
- at all understanding exactly what the program is doing, but you may
- be a bit confused at the meaning of the result found in line 38
- where we multiply the height of the square with the width of the
- box. This is perfectly legal to do in ANSI-C or C++, but the
-
- Page 5-5
-
- Chapter 5 - Encapsulation
-
- result has no earthly meaning because the data are for two
- different entities. Likewise, the result calculated in line 40 is
- even sillier because the product of the height of the square and
- the depth of the flagpole has absolutely no meaning in any physical
- real world system we can think up.
-
- Wouldn't it be neat if we had a way to prevent such stupid things
- from happening in a large production program. If we had a good
- program that defined all of the things we can do with a square and
- another program that defined everything we could do with a pole,
- and if the data could be kept mutually exclusive, we could prevent
- these silly things from happening.
-
- It should come as no real surprise to you that the next program
- will do just those things for us and do it in a very elegant way.
- Before proceeding on to the next example program, you should
- compile and execute this one even though it displays some silly
- results.
-
-
-
- OBJECTS PROTECT DATA
- _________________________________________________________________
-
- Examine the program named CLASPOLE.CPP as an ================
- example of data protection in a very simple CLASPOLE.CPP
- program. ================
-
- In this program the rectangle is changed to a
- class with the same two variables which are now private, and two
- methods to handle the private data. One method is used to
- initialize the values of the objects created and the other method
- to return the area of the object. The two methods are defined in
- lines 12 through 21 in the manner described earlier in this
- chapter. The pole is left as a structure to illustrate that the
- two can be used together and that C++ is truly an extension of
- ANSI-C.
-
- In line 33 we declare two objects, once again named box and square,
- but this time we cannot assign values directly to their individual
- components because they are private elements of the class. Lines
- 36 through 38 are commented out for that reason and the messages
- are sent to the objects in lines 40 and 41 to tell them to
- initialize themselves to the values input as parameters. The
- flag_pole is initialized in the same manner as in the previous
- program. Using the class in this way prevents us from making the
- silly calculations we did in the last program. The compiler is now
- being used to prevent the erroneous calculations. The end result
- is that the stupid calculations we did in the last program are not
- possible in this program so lines 50 through 53 have been commented
- out. Once again, it is difficult to see the utility of this in
- such a simple program. In a large program, using the compiler to
- enforce the rules can pay off in a big way.
-
-
-
- Page 5-6
-
- Chapter 5 - Encapsulation
-
- This is the abstract data type mentioned earlier in this chapter,
- a model with an allowable set of variables for data storage and a
- set of allowable operations that can be performed on that stored
- data. The only operations that can be performed on the data are
- those defined by the methods which prevents many kinds of erroneous
- or silly operations. Encapsulation and data hiding bind the data
- and procedures, or methods, tightly together and limit the scope
- and visibility of each. Once again, we have the divide and conquer
- technique in which an object is separated from the rest of the code
- and carefully developed in complete isolation from it. Only then
- is it integrated into the rest of the code with a few very simple
- interfaces.
-
-
-
- HAVE YOU EVER USED THIS TECHNIQUE BEFORE?
- _________________________________________________________________
-
- A good example of the use of this technique is in the file commands
- you have been using with ANSI-C. The data in the file is only
- available through the predefined functions provided by your
- compiler writer. You have no direct access to the actual data
- because it is impossible for you to address the actual data stored
- on the disk. The data is therefore private data, as far as you are
- concerned, but the available functions are very much like methods
- in C++. There are two aspects of this technique that really count
- when you are developing software. First, you can get all of the
- data you really need from the file system because the interface is
- complete, but secondly, you cannot get any data that you do not
- need. You are prevented from getting into the file handling system
- and accidentally corrupting some data stored within it. You are
- also prevented from using the wrong data because the functions
- available demand a serial access to the data.
-
- Another example is in the monitor and keyboard handling routines.
- You are prevented from getting into the workings of them and either
- corrupting them accidentally, or on purpose if you have such a
- bent, but once again, you are provided with all of the data
- interfaces that you really need.
-
-
- Suppose you are developing a program to analyze some
- characteristics of flagpoles. You would not wish to accidentally
- use some data referring to where the flagpole program was stored
- on your hard disk as the height of the flagpole, nor would you wish
- to use the cursor position as the flagpole thickness or color. The
- fact that the data is hidden from you protects you from
- accidentally doing such a thing when you are working at midnight
- to try to meet a schedule. Once again, this is referred to as
- information hiding and is one of the primary advantages of object
- oriented programming over other methods. Based on the discussion
- given above you can see that object oriented programming is not
- really new, since it has been used in some degree for as long as
- computers have been popular. The newest development, however, is
-
- Page 5-7
-
- Chapter 5 - Encapsulation
-
- in allowing the programmer to partition his programs in such a way
- that he too can practice information hiding and reduce the
- debugging time.
-
-
-
- WHAT DOES THIS COST?
- _________________________________________________________________
-
- It should be clear that this technique will cost you something in
- efficiency because every access to the elements of the object will
- require the time and inefficiency of a call to a function, or
- perhaps I should be more proper and refer to it as a method. The
- time saved in building a large program, however, could easily be
- saved in debug time when it comes time to iron out the last few
- bugs. This is because a program made up of objects that closely
- match the application are much easier to understand than a program
- that does not.
-
- This is obviously such a small program that it is silly to try to
- see any gain with this technique. In a real project however, it
- could be a great savings if one person developed all of the details
- of the rectangle, programmed it, and made it available to you to
- simply use. This is exactly what has been done for you if you
- consider the video monitor an object. There is a complete set of
- preprogrammed and debugged routines you can use to make the monitor
- do anything you wish it to do, all you have to do is study the
- interface to the routines and use them, expecting them to work.
- As a silly example of protection, it is impossible for you to
- multiply the size of your monitor screen by the depth of the flag
- pole because that information is not available to you to use in a
- corruptible way.
-
- After you understand some of the advantages of this style of
- programming, be sure to compile and execute this program.
-
-
-
- CONSTRUCTORS AND DESTRUCTORS
- _________________________________________________________________
-
- The file named CONSPOLE.CPP introduces ================
- constructors and destructors and should be CONSPOLE.CPP
- examined at this time. ================
-
- This program is identical to the last program
- except that a constructor has been added as well as a destructor.
- The constructor is declared in line 8 and defined in lines 14
- through 18. The constructor is called automatically by the C++
- system when the object is declared and can therefore be of great
- help in preventing the use of an uninitialized variable. When the
- object named box is declared in line 46, the constructor is called
- automatically by the system which sets the values of its height and
- width each to 6. This is printed out for reference in lines 49 and
-
- Page 5-8
-
- Chapter 5 - Encapsulation
-
- 50. Likewise, when the square is declared in line 46, the values
- of the height and the width of the square are each initialized to
- 6 when the constructor is called automatically.
-
- A constructor is defined as having the same name as the class
- itself. In this case both are named rectangle. The constructor
- cannot have a return type associated with it since it is not
- permitted to have a user defined return type. It actually has a
- predefined return type, a pointer to the object itself, but we will
- not be concerned about this until much later in this tutorial.
- Even though both objects are assigned values by the constructor,
- they are initialized in lines 58 and 59 to new values and
- processing continues. Since we have a constructor that does the
- initialization, we should probably rename the method named
- initialize() something else but it illustrates the concept involved
- here.
-
- The destructor is very similar to the constructor except that it
- is called automatically when each of the objects goes out of scope.
- You will recall that automatic variables have a limited lifetime
- since they cease to exist when the enclosing block in which they
- were declared is exited. When an object is about to be
- automatically deallocated, its destructor, if one exists, is called
- automatically. A destructor is characterized as having the same
- name as the class but with a tilde prepended to the class name.
- A destructor has no return type.
-
- A destructor is declared in line 11 and defined in lines 31 through
- 35. In this case the destructor only assigns zeros to the
- variables prior to their being deallocated, so nothing is really
- accomplished. The destructor is only included for illustration of
- how it is used. If some blocks of memory were dynamically
- allocated within an object, a destructor should be used to
- deallocate them prior to losing the pointers to them. This would
- return their memory to the free store for further use later in the
- program.
-
- It is interesting to note that if a constructor is used for an
- object that is declared prior to the main program, otherwise known
- as globally, the constructor will actually be executed prior to the
- execution of the main program. In like manner, if a destructor is
- defined for such a variable, it will execute following the
- completion of execution of the main program. This will not
- adversely affect your programs, but it is interesting to make note
- of.
-
-
-
- OBJECT PACKAGING
- _________________________________________________________________
-
- Examine the file named BOXES1.CPP for an example of how not to
- package an object for universal use. This packaging is actually
- fine for a very small program but is meant to illustrate to you
-
- Page 5-9
-
- Chapter 5 - Encapsulation
-
- how to split your program up into smaller more ================
- manageable files when you are developing a large BOXES1.CPP
- program or when you are part of a team ================
- developing a large system. The last three
- example programs in this chapter will illustrate
- the proper method of packaging a class.
-
- This program is very similar to the last one with the pole
- structure dropped and the class named box. The class is defined
- in lines 4 through 12, the implementation of the class is given in
- lines 15 through 34, and the use of the class is given in lines 37
- through 50. With the explanation we gave about the last program,
- the diligent student should have no problem understanding this
- program in detail.
-
-
-
- INLINE IMPLEMENTATION
- _________________________________________________________________
-
- The method in line 10 contains the implementation for the method
- as a part of the declaration because it is very simple, and because
- it introduces another new topic which you will use often in C++
- programming. When the implementation is included in the
- declaration, it will be assembled inline wherever this function is
- called leading to much faster code. This is because there is no
- overhead to accomplish the call to the method. In some cases this
- will lead to code that is both smaller and faster. This is yet
- another illustration of the efficiency built into the C++
- programming language.
-
- Compile and execute this program in preparation for our study of
- the next three examples which are a repeat of this program in a
- slightly different form.
-
-
-
- THE CLASS HEADER FILE
- _________________________________________________________________
-
- If you examine BOX.HPP carefully, you will see ===============
- that it is only the class definition. No BOX.HPP
- details are given of how the various methods are ===============
- implemented except of course for the inline
- method named get_area(). This gives the
- complete definition of how to use the class with no implementation
- details. You would be advised to keep a hardcopy of this file
- available as we study the next two files. You will notice that it
- contains lines 4 through 12 of the previous example program named
- BOXES1.CPP.
-
- This is called the class header file and cannot be compiled or
- executed.
-
-
- Page 5-10
-
- Chapter 5 - Encapsulation
-
- THE CLASS IMPLEMENTATION FILE
- _________________________________________________________________
-
- Examine the file named BOX.CPP for the ===============
- implementation of the methods declared in the BOX.CPP
- class header file. Notice that the class header ===============
- file is included into this file in line 2 which
- contains all of the prototypes for its methods.
- The code from lines 15 through 34 of BOXES1.CPP is contained in
- this file which is the implementation of the methods declared in
- the class named box.
-
- This file can be compiled but it cannot be executed because there
- is no main entry point which is required for all ANSI-C or C++
- programs. When it is compiled, the object code will be stored in
- the current directory and available for use by other programs. It
- should be noted here that the result of compilation is usually
- referred to as an object file because it contains object code.
- This use of the word object has nothing to do with the word object
- as used in object oriented programming. It is simply a matter of
- overloading the use of the word. The practice of referring to the
- compiled result as a object file began long before the method of
- object oriented programming was ever considered.
-
- The separation of the definition and the implementation is a major
- step forward in software engineering. The definition file is all
- the user needs in order to use this class effectively in a program.
- He needs no knowledge of the actual implementation of the methods.
- If he had the implementation available, he may study the code and
- find a trick he could use to make the overall program slightly more
- efficient, but this would lead to nonportable software and possible
- bugs later if the implementor changed the implementation without
- changing the interface. The purpose of object oriented programming
- is to hide the implementation in such a way that the implementation
- can not affect anything outside of its own small and well defined
- boundary or interface.
-
- You should compile this program now and we will use the result with
- the next example program.
-
-
-
- USING THE BOX OBJECT
- _________________________________________________________________
-
- Examine the file named BOXES2.CPP and you will ================
- find that the object we defined previously is BOXES2.CPP
- used within this file. In fact, these last ================
- three programs taken together are identical to
- the program named BOXES1.CPP studied earlier.
-
- The BOX.HPP file is included here, in line 3, since the definition
- of the box is needed to declare three objects and use their
- methods. You should have no trouble seeing that this is a repeat
-
- Page 5-11
-
- Chapter 5 - Encapsulation
-
- of the previous program and will execute in exactly the same way.
- There is a big difference in BOXES1.CPP and BOXES2.CPP as we will
- see shortly.
-
- A very important distinction must be made at this point. We are
- not merely calling functions and changing the terminology a little
- to say we are sending messages. There is an inherent difference
- in the two operations. Since the data for each object is tightly
- bound up in the object, there is no way to get to the data except
- through the methods and we send a message to the object telling it
- to perform some operation based on its internally stored data.
- However, whenever we call a function, we take along the data for
- it to work with as parameters since it doesn't contain its own
- data.
-
- Be sure to compile and execute this program, but when you come to
- the link step, you will be required to link this program along with
- the result of the compilation when you compiled the class named
- box. The file is probably named BOX.OBJ that must be linked with
- this file. You may need to consult the documentation for your C++
- compiler to learn how to do this. Even if it seems to be a lot of
- trouble to learn how to link several files together, it will be
- worth your time to do so now because we will be linking several
- more multifile C++ programs in the remainder of this tutorial.
-
- If you are using TURBO C++, this is your first opportunity to use
- a project file. If you are using Zortech C++, you can use the make
- facility included with your compiler. Whichever one you are using,
- it would pay you to stop and learn how to use the multifile
- technique provided with your compiler because you will need to use
- it several times before the end of this tutorial. The nature of
- C++ tends to drive the programmer to use many files for a given
- programming project and you should develop the habit early.
-
-
-
- INFORMATION HIDING
- _________________________________________________________________
-
- The last three example programs illustrate a method of information
- hiding that can have a significant impact on the quality of
- software developed for a large project. Since the only information
- the user of the class really needs is the class header, that is all
- he needs to be given. The details of implementation can be kept
- hidden from him to prevent him from studying the details and
- possibly using a quirk of programming to write some rather obtuse
- code. Since he doesn't know exactly what the implementor did, he
- must follow only the definition given in the header file. This can
- have a significant impact on a large project. As mentioned
- earlier, accidental corruption of data is prevented also.
-
- Another reason for hiding the implementation is economic. The
- company that supplied you with your C++ compiler gave you many
- library functions but did not supply the source code to the library
-
- Page 5-12
-
- Chapter 5 - Encapsulation
-
- functions, only the interface to each function. You know how to
- use the file access functions but you do not have the details of
- implementation, nor do you need them. Likewise a class development
- industry can develop which supplies users with libraries of high
- quality, completely developed and tested classes, for a licensing
- fee of course. Since the user only needs the interface defined,
- he can be supplied with the interface and the object (compiled)
- code for the object and can use it in any way he desires. The
- suppliers source code is protected from accidental or intentional
- compromise and he can maintain complete control over it.
-
- It is very important that you understand the principles covered in
- this chapter before proceeding on to the next chapter. If you feel
- you are a little weak in any of the areas covered here, you should
- go over them again before proceeding on. A point that should be
- made here that may be obvious to you, is that it requires some
- amount of forethought to effectively use classes.
-
-
-
- ABSTRACT DATA TYPES
- _________________________________________________________________
-
- We mentioned the abstract data type at the beginning of this
- chapter and again briefly midway through, and it is time to
- describe it a little more completely. An abstract data type is a
- group of data, each of which can store a range of values, and a set
- of methods or functions that can operate on that data. Since the
- data are protected from any outside influence, it is protected and
- said to be encapsulated. Also, since the data is somehow related,
- it is a very coherent group of data that may be highly interactive
- with each other, but with no interaction with the outside world,
- it is completely decoupled from its surroundings.
-
- The methods, on the other hand, are coupled to the outside world
- through the interface, but there are a limited number of contacts
- with the outside world and therefore a weak coupling with the
- outside. The object is therefore said to be loosely coupled to the
- outside world. Because of the tight coherency and the loose
- coupling, ease of maintenance of the software is greatly enhanced.
- The ease of maintenance may be the greatest benefit of object
- oriented programming.
-
- It may bother you that even though the programmer may not use the
- private variables directly outside of the class, they are in plain
- sight and he can see what they are and can probably make a good
- guess at exactly how the class is implemented. The variables could
- have been hidden completely out of sight in another file, but
- because the designers of C++ wished to make the execution of the
- completed application as efficient as possible, the variables were
- left in the class definition where they can be seen but not used.
-
-
-
-
- Page 5-13
-
- Chapter 5 - Encapsulation
-
- FRIEND FUNCTIONS
- _________________________________________________________________
-
- A function outside of a class can be defined to be a friend
- function by the class which gives the friend free access to the
- private members of the class. This in effect, opens a small hole
- in the protective shield of the class, so it should be used very
- carefully and sparingly. There are cases where it helps to make
- a program much more understandable and allows controlled access to
- the data. Friend functions will be illustrated in some of the
- example programs later in this tutorial. It is mentioned here for
- completeness of this section. A single function can be declared
- as a friend, as well as members of other classes, and even entire
- classes can be given friend status if needed in a program. Neither
- a constructor nor a destructor can be a friend function.
-
-
- THE struct IN C++
- _________________________________________________________________
-
- The struct is still useable in C++ and operates just like it does
- in ANSI-C with one addition. You can include methods in a
- structure that operate on data in the same manner as in a class,
- but all methods and data are automatically defaulted to be public
- in a structure. Of course you can make any of the data or methods
- private but only if you are using a C++ compiler that supports C++
- version 2.0 or higher. Earlier versions of C++ did not permit a
- private section in a structure. The structure should be used only
- for constructs that are truly structures. If you are building even
- the simplest objects, use classes to define them.
-
-
- INITIALIZING THE class AND struct
- _________________________________________________________________
-
- The struct can be initialized with an aggregate in exactly the same
- manner that a struct can be initialized in ANSI-C, but this is not
- permitted for a class. The class is allowed to contain private
- members, so it cannot be initialized without access to the private
- members. It could have been possible to allow aggregate
- initialization of classes without private members, but this would
- have greatly complicated the compiler while adding little to the
- capability since a class without a private member is contrary to
- the entire thrust of object oriented programming. The designers
- of C++ chose therefore to prohibit aggregate initialization of
- class variables in order to simplify the job of the compiler
- writer. This probably adds to the efficiency of the resulting
- applications. This really is no limitation because both struct and
- class types can be initialized with constructors or initialization
- methods.
-
- We will continue our discussion of encapsulation in the next
- chapter.
-
-
- Page 5-14
-
- Chapter 5 - Encapsulation
-
-
- PROGRAMMING EXERCISES
- _________________________________________________________________
-
-
- 1. Add a method to CLAS.CPP which will supply the square of the
- stored value. Include some code in the main program to read
- and display the squared values.
-
- 2. Continuing with CLAS.CPP, add a constructor to initialize the
- stored value to 10 and add a few lines of code to the main
- program to display the values immediately following the object
- definition.
-
- 3. Add an output statement to the rectangle constructor of the
- program named CONSPOLE.CPP and another to the destructor to
- prove to yourself that they really are called by the system
- when we said they are.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Page 5-15